home *** CD-ROM | disk | FTP | other *** search
/ Enter 2006 September / Enter 09 2006.iso / Internet / SpamExperts Home 1.1 / SpamExperts Home.exe / lib / spamexperts.modules / ImageFile.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-07-14  |  9.9 KB  |  429 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import Image
  5. import traceback
  6. import sys
  7. import string
  8. import os
  9. MAXBLOCK = 65536
  10. SAFEBLOCK = 1024 * 1024
  11. ERRORS = {
  12.     -1: 'image buffer overrun error',
  13.     -2: 'decoding error',
  14.     -3: 'unknown error',
  15.     -8: 'bad configuration',
  16.     -9: 'out of memory error' }
  17.  
  18. def _tilesort(t1, t2):
  19.     return cmp(t1[2], t2[2])
  20.  
  21.  
  22. class ImageFile(Image.Image):
  23.     '''Base class for image file format handlers.'''
  24.     
  25.     def __init__(self, fp = None, filename = None):
  26.         Image.Image.__init__(self)
  27.         self.tile = None
  28.         self.readonly = 1
  29.         self.decoderconfig = ()
  30.         self.decodermaxblock = MAXBLOCK
  31.         if Image.isStringType(fp):
  32.             self.fp = open(fp, 'rb')
  33.             self.filename = fp
  34.         else:
  35.             self.fp = fp
  36.             self.filename = filename
  37.         
  38.         try:
  39.             self._open()
  40.         except IndexError:
  41.             v = None
  42.             if Image.DEBUG > 1:
  43.                 traceback.print_exc()
  44.             
  45.             raise SyntaxError, v
  46.         except TypeError:
  47.             v = None
  48.             if Image.DEBUG > 1:
  49.                 traceback.print_exc()
  50.             
  51.             raise SyntaxError, v
  52.         except KeyError:
  53.             v = None
  54.             if Image.DEBUG > 1:
  55.                 traceback.print_exc()
  56.             
  57.             raise SyntaxError, v
  58.         except EOFError:
  59.             v = None
  60.             if Image.DEBUG > 1:
  61.                 traceback.print_exc()
  62.             
  63.             raise SyntaxError, v
  64.  
  65.         if not (self.mode) or self.size[0] <= 0:
  66.             raise SyntaxError, 'not identified by this driver'
  67.         
  68.  
  69.     
  70.     def draft(self, mode, size):
  71.         '''Set draft mode'''
  72.         pass
  73.  
  74.     
  75.     def verify(self):
  76.         '''Check file integrity'''
  77.         self.fp = None
  78.  
  79.     
  80.     def load(self):
  81.         '''Load image data based on tile list'''
  82.         Image.Image.load(self)
  83.         if self.tile is None:
  84.             raise IOError('cannot load this image')
  85.         
  86.         if not self.tile:
  87.             return None
  88.         
  89.         self.map = None
  90.         readonly = 0
  91.         if self.filename and len(self.tile) == 1:
  92.             (d, e, o, a) = self.tile[0]
  93.             if d == 'raw' and a[0] == self.mode and a[0] in Image._MAPMODES:
  94.                 
  95.                 try:
  96.                     if hasattr(Image.core, 'map'):
  97.                         self.map = Image.core.map(self.filename)
  98.                         self.map.seek(o)
  99.                         self.im = self.map.readimage(self.mode, self.size, a[1], a[2])
  100.                     else:
  101.                         import mmap
  102.                         file = open(self.filename, 'r+')
  103.                         size = os.path.getsize(self.filename)
  104.                         self.map = mmap.mmap(file.fileno(), size)
  105.                         self.im = Image.core.map_buffer(self.map, self.size, d, e, o, a)
  106.                     readonly = 1
  107.                 except (AttributeError, IOError, ImportError):
  108.                     self.map = None
  109.                 except:
  110.                     None<EXCEPTION MATCH>(AttributeError, IOError, ImportError)
  111.                 
  112.  
  113.             None<EXCEPTION MATCH>(AttributeError, IOError, ImportError)
  114.         
  115.         self.load_prepare()
  116.         
  117.         try:
  118.             read = self.load_read
  119.         except AttributeError:
  120.             read = self.fp.read
  121.  
  122.         
  123.         try:
  124.             seek = self.load_seek
  125.         except AttributeError:
  126.             seek = self.fp.seek
  127.  
  128.         if not self.map:
  129.             self.tile.sort(_tilesort)
  130.             
  131.             try:
  132.                 prefix = self.tile_prefix
  133.             except AttributeError:
  134.                 prefix = ''
  135.  
  136.             for d, e, o, a in self.tile:
  137.                 d = Image._getdecoder(self.mode, d, a, self.decoderconfig)
  138.                 seek(o)
  139.                 
  140.                 try:
  141.                     d.setimage(self.im, e)
  142.                 except ValueError:
  143.                     continue
  144.  
  145.                 b = prefix
  146.                 t = len(b)
  147.                 while None:
  148.                     s = read(self.decodermaxblock)
  149.                     if not s:
  150.                         self.tile = []
  151.                         raise IOError('image file is truncated (%d bytes not processed)' % len(b))
  152.                     
  153.                     b = b + s
  154.                     (n, e) = d.decode(b)
  155.                     if n < 0:
  156.                         break
  157.                     
  158.                     b = b[n:]
  159.                     t = t + n
  160.             
  161.         
  162.         self.tile = []
  163.         self.readonly = readonly
  164.         self.fp = None
  165.         if not (self.map) and e < 0:
  166.             error = ERRORS.get(e, 'decoder error %d' % e)
  167.             raise IOError(error + ' when reading image file')
  168.         
  169.         if hasattr(self, 'tile_post_rotate'):
  170.             self.im = self.im.rotate(self.tile_post_rotate)
  171.             self.size = self.im.size
  172.         
  173.         self.load_end()
  174.  
  175.     
  176.     def load_prepare(self):
  177.         if not (self.im) and self.im.mode != self.mode or self.im.size != self.size:
  178.             self.im = Image.core.new(self.mode, self.size)
  179.         
  180.         if self.mode == 'P':
  181.             Image.Image.load(self)
  182.         
  183.  
  184.     
  185.     def load_end(self):
  186.         pass
  187.  
  188.  
  189.  
  190. class StubImageFile(ImageFile):
  191.     '''Base class for stub image loaders.'''
  192.     
  193.     def _open(self):
  194.         raise NotImplementedError('StubImageFile subclass must implement _open')
  195.  
  196.     
  197.     def load(self):
  198.         loader = self._load()
  199.         if loader is None:
  200.             raise IOError('cannot find loader for this %s file' % self.format)
  201.         
  202.         image = loader.load(self)
  203.         if not image is not None:
  204.             raise AssertionError
  205.         self.__class__ = image.__class__
  206.         self.__dict__ = image.__dict__
  207.  
  208.     
  209.     def _load(self):
  210.         raise NotImplementedError('StubImageFile subclass must implement _load')
  211.  
  212.  
  213.  
  214. class _ParserFile:
  215.     
  216.     def __init__(self, data):
  217.         self.data = data
  218.         self.offset = 0
  219.  
  220.     
  221.     def close(self):
  222.         self.data = None
  223.         self.offset = None
  224.  
  225.     
  226.     def tell(self):
  227.         return self.offset
  228.  
  229.     
  230.     def seek(self, offset, whence = 0):
  231.         if whence == 0:
  232.             self.offset = offset
  233.         elif whence == 1:
  234.             self.offset = self.offset + offset
  235.         else:
  236.             raise IOError('illegal argument to seek')
  237.  
  238.     
  239.     def read(self, bytes = 0):
  240.         pos = self.offset
  241.         if bytes:
  242.             data = self.data[pos:pos + bytes]
  243.         else:
  244.             data = self.data[pos:]
  245.         self.offset = pos + len(data)
  246.         return data
  247.  
  248.     
  249.     def readline(self):
  250.         s = ''
  251.         while None:
  252.             c = self.read(1)
  253.             if not c:
  254.                 break
  255.             
  256.             s = s + c
  257.             if c == '\n':
  258.                 break
  259.                 continue
  260.         return s
  261.  
  262.  
  263.  
  264. class Parser:
  265.     incremental = None
  266.     image = None
  267.     data = None
  268.     decoder = None
  269.     finished = 0
  270.     
  271.     def reset(self):
  272.         if not self.data is None:
  273.             raise AssertionError, 'cannot reuse parsers'
  274.  
  275.     
  276.     def feed(self, data):
  277.         if self.finished:
  278.             return None
  279.         
  280.         if self.data is None:
  281.             self.data = data
  282.         else:
  283.             self.data = self.data + data
  284.         if self.decoder:
  285.             if self.offset > 0:
  286.                 skip = min(len(self.data), self.offset)
  287.                 self.data = self.data[skip:]
  288.                 self.offset = self.offset - skip
  289.                 if self.offset > 0 or not (self.data):
  290.                     return None
  291.                 
  292.             
  293.             (n, e) = self.decoder.decode(self.data)
  294.             if n < 0:
  295.                 self.data = None
  296.                 self.finished = 1
  297.                 if e < 0:
  298.                     self.image = None
  299.                     error = ERRORS.get(e, 'decoder error %d' % e)
  300.                     raise IOError(error + ' when reading image file')
  301.                 else:
  302.                     return None
  303.             
  304.             self.data = self.data[n:]
  305.         elif self.image:
  306.             pass
  307.         else:
  308.             
  309.             try:
  310.                 
  311.                 try:
  312.                     fp = _ParserFile(self.data)
  313.                     im = Image.open(fp)
  314.                 finally:
  315.                     fp.close()
  316.  
  317.             except IOError:
  318.                 pass
  319.  
  320.             if not hasattr(im, 'load_seek'):
  321.                 pass
  322.             flag = hasattr(im, 'load_read')
  323.             if flag or len(im.tile) != 1:
  324.                 self.decode = None
  325.             else:
  326.                 im.load_prepare()
  327.                 (d, e, o, a) = im.tile[0]
  328.                 im.tile = []
  329.                 self.decoder = Image._getdecoder(im.mode, d, a, im.decoderconfig)
  330.                 self.decoder.setimage(im.im, e)
  331.                 self.offset = o
  332.                 if self.offset <= len(self.data):
  333.                     self.data = self.data[self.offset:]
  334.                     self.offset = 0
  335.                 
  336.             self.image = im
  337.  
  338.     
  339.     def close(self):
  340.         if self.decoder:
  341.             self.feed('')
  342.             self.data = None
  343.             self.decoder = None
  344.             if not self.finished:
  345.                 raise IOError('image was incomplete')
  346.             
  347.         
  348.         if not self.image:
  349.             raise IOError('cannot parse this image')
  350.         
  351.         if self.data:
  352.             
  353.             try:
  354.                 fp = _ParserFile(self.data)
  355.                 self.image = Image.open(fp)
  356.             finally:
  357.                 fp.close()
  358.  
  359.         
  360.         return self.image
  361.  
  362.  
  363.  
  364. def _save(im, fp, tile):
  365.     '''Helper to save image based on tile list'''
  366.     im.load()
  367.     if not hasattr(im, 'encoderconfig'):
  368.         im.encoderconfig = ()
  369.     
  370.     tile.sort(_tilesort)
  371.     bufsize = max(MAXBLOCK, im.size[0] * 4)
  372.     
  373.     try:
  374.         fh = fp.fileno()
  375.         fp.flush()
  376.     except AttributeError:
  377.         for e, b, o, a in tile:
  378.             e = Image._getencoder(im.mode, e, a, im.encoderconfig)
  379.             if o > 0:
  380.                 fp.seek(o, 0)
  381.             
  382.             e.setimage(im.im, b)
  383.             while None:
  384.                 (l, s, d) = e.encode(bufsize)
  385.                 if s:
  386.                     break
  387.                     continue
  388.             if s < 0:
  389.                 raise IOError('encoder error %d when writing image file' % s)
  390.                 continue
  391.         
  392.  
  393.     for e, b, o, a in tile:
  394.         e = Image._getencoder(im.mode, e, a, im.encoderconfig)
  395.         if o > 0:
  396.             fp.seek(o, 0)
  397.         
  398.         e.setimage(im.im, b)
  399.         s = e.encode_to_file(fh, bufsize)
  400.         if s < 0:
  401.             raise IOError('encoder error %d when writing image file' % s)
  402.             continue
  403.     
  404.     
  405.     try:
  406.         fp.flush()
  407.     except:
  408.         pass
  409.  
  410.  
  411.  
  412. def _safe_read(fp, size):
  413.     if size <= 0:
  414.         return ''
  415.     
  416.     if size <= SAFEBLOCK:
  417.         return fp.read(size)
  418.     
  419.     data = []
  420.     while size > 0:
  421.         block = fp.read(min(size, SAFEBLOCK))
  422.         if not block:
  423.             break
  424.         
  425.         data.append(block)
  426.         size = size - len(block)
  427.     return string.join(data, '')
  428.  
  429.